A virtual world represents a real or imaginary place using graphics, images, video, force feedback, and audio data to define a representation of the place on a computer for one or more users. Typically, the virtual world enables multiple users to simultaneously perceive and interact with the virtual world and with each other through different computers that are connected by a network.
Large-scale virtual worlds have been developed for two different kinds of systems: military simulation networks and text-based multi-user worlds or domains known as MUDs. A military simulation network known as SIMNET is based on vehicle and flight simulators that generate real-time 3-D images of a virtual world. A peer-to-peer network protocol allows simulators to place other users' vehicles and projectiles during virtual battle simulations.
A distinction of such a military simulation network is that complete graphical representations are transmitted to all users simultaneously. While transmitting complete graphical representations in applications such as military simulation can require extensive network bandwidth, transmission of complete graphical representations is also used in lower bandwidth applications such as VRML. It will be appreciated, however, that with the bandwidth requirements of a modeling language such as VRML it does not have a way to provide simultaneous full-featured control to large number of users.
Text-based MUDs maintain long term persistent worlds on a central server that is accessed via clients. An object oriented MUD, referred to as a MOO, is a network database server that stores text objects having properties and methods. The topology of the space in a MOO is defined by room objects that represent discrete locations and are interconnected by portal objects. Objects in a MOO can also represent things located in a room, and objects called players or avatars represent the users' characters in the world. Users in the same room are able to talk by typing text and reading the text that others type.
Text-based MUDs and MOOs are capable of providing a rich virtual world experience, but that experience could be further enhanced by graphical and other multimedia presentation characteristics (e.g., graphics, audio, force feedback, etc.). A difficulty is the volume of data required to provide a virtual world experience simultaneously to multiple users, particularly large numbers of users. While even a server of modest capability (e.g., 100 MHz Pentium processor) is capable of supporting a text-based MUD or MOO for up to about 300 users, a multimedia MUD or MOO would require significantly greater server processing power and significant network bandwidth as well.
Some graphical virtual world systems, including graphical chat systems, overcome the server power and network bandwidth requirements by requiring that much of the virtual world be immutable and transmitted to the user's client in an initial download. Subsequent updates that are transmitted from the server to the clients are of only limited feature changes, such as changing positions of entities or objects within a fixed space. Some multi-user 3D games (e.g., Doom, Duke Nukem, Quake, etc.) utilize such multi-casting of player-state messages to provide fast action performance. However, these games lack the persistence of text-based MUDs and MOOs in which user characteristics, such as the attributes and properties of entities controlled by a user, are maintained in a server database as a part of the MUD or MOO. By fixing much of the virtual world and by lacking user entity persistence, such multi-user games lack the richness available within a MUD or MOO virtual world environment.
In accordance with the present invention, therefore, a database of objects distributed between a server computer and multiple client computers supports an object oriented virtual world environment (VWE) with multimedia presentation features. It will be appreciated that a VWE in this context is not limited to the recreational applications, such as multi-user games or chats that are associated with MOOs. A VWE in this context is also applicable to multi-user collaboration in simulations, designs, or modeling, multi-user participation in presentations or demonstrations, as well as other non-recreational applications.
A primary database is maintained on the server and includes at least one entry for each object disposed within the VWE. Typically, each client has an object that functions as the point of access to the database for the user of the client. In a VWE implementation the point of access object for each client is an avatar (i.e., a virtual being or entity) that is associated with the user.
A copy of the portion of the VWE that is immediately accessible to the avatar is maintained on the user's client as a local database. In one implementation, the accessible region of the virtual world is the avatar itself, the avatar's location (e.g. the room the avatar is in), objects in the avatar contents (e.g., what the avatar is carrying), and objects in the contents of the avatar's location (e.g., things in the same room as the avatar). If any of these accessible objects is an open container, its contents is also included in the accessible set. The server marshals these accessible objects to the avatar client when a user logs into the system and activates an avatar or when an avatar changes location to a new room.
The local database contains an entry for each object that is disposed within a bystander region of, for example, the user's avatar object. A change in a property of a selected object caused by one of multiple other users is transmitted to the server that maintains the world database. The world database is updated by the server computer to include the change in the property of the selected object, and affected objects disposed in the bystander region of the selected object are determined.
The change in the property of the selected object is then entered in the local database maintained by the client computer of each user associated with an affected object. This change is conveyed by the server computer to each such client computer. Thus, the change is provided for the users who are associated with affected objects. Further, the change in the property of the selected object is displayed by the client computer of each affected object that senses the change and is being displayed.
Each entry in the local database and in the world database specifies a plurality of properties and a type for the associated object disposed within the VWE. In one implementation, the base types for an object disposed within the VWE an avatar, an artifact, a portal, or a room. Furthermore, the plurality of properties for each object disposed within the VWE comprises at least one of a name, a geometry, an owner, a location, and a contents list. Each object disposed within the VWE that comprises a container preferably includes a content property and is identified as either an open container or a closed container. An object included in the contents list of a container is not sensed by objects disposed within the bystander region of the container unless the container is identified as an open container.
A conventional software object provides software services, such as methods or properties, that are accessed by one or more interfaces. A method is typically a function or procedure that performs a specific action and is called via a corresponding interface. A property is typically information or data and is also called via a corresponding interface. Conventional objects include the characteristic of interface inheritance in which the definitions of the methods that an interface supports may be inherited by another interface. The interfaces may be of different objects that may or may not be of the same class of objects. An object supporting an inherited interface can be treated like the object from which the interface is inherited. Such objects may be implemented by or in accordance with many object-oriented programming tools or models including, for example, the component object model (COM).
An interface of an object may not be changed once the design and implementation of the interface is complete and the object is established, distributed, or promulgated for general run-time use. Adding new services to or modifying existing services in such an object requires that a new interface be defined in a design-time operation. The new interface would then be distributed or promulgated for general run-time use. The new interface may inherit services from an existing interface, but the new interface remains distinct and has a unique identifier. Despite interface inheritance, therefore, interfaces remain static once they have been established, distributed, or promulgated for use at run-time.
An implementation of the present invention provides, therefore, that object services like methods or properties are provided to or inherited by objects dynamically during run-time. This dynamic inheritance may be provided within the context of an object model, such as the Component Object Model, that supports only design-time inheritance. As applied in a virtual world environment, for example, dynamic inheritance can provide users with increased levels of interaction or control.
In a method of providing dynamic inheritance, hierarchical relationships are defined between multiple objects such that each object references or is referenced by another object. One of the objects is a root object that is referenced by at least one other object but that does not reference another object. A call is made for a particular service (e.g., a method or property) at a selected object. The service is provided directly from the object whenever the service is available therefrom.
Whenever the selected service is unavailable at the selected object, the call is passed to a referenced object (i.e., an object that is referenced by the selected object). The service is provided directly from the referenced object whenever the service is available therefrom or the call is passed to yet another referenced object until the service can be provided. The call may be passed to multiple successive referenced objects until the call reaches the root object, which either provides the service or the service is deemed unavailable.
Another aspect of dynamic inheritance is that an object, such as the root object, may include one or more methods for adding or otherwise changing the methods or properties available from that object. The changes in the methods or properties may be made at run-time, after the object has been otherwise fixed or established.
In one implementation, the interface includes an AddMethod method that adds a designated method to the interface at run-time to make the method available from the interface. Similarly, the interface includes an AddProperty method that adds a designated property to a designated interface at run-time to make the property available from the interface. An InvokeMethod method allows a user to execute the designated method, and other methods can allow other access to and control over the methods and properties. Methods and properties available for implementation or access by these dynamic inheritance methods may be in a dynamic inheritance listing, such as a table, that indicates the names of the methods and properties, defines the services they provide, and includes unique identifiers for them.
Further in accordance with an implementation of the present invention, a dynamic or latebound event mechanism provides event mechanism operation according to associational relationships among objects. In addition, objects may be responsive to event notification methods that are not initially within the original object definition, thereby allowing the event notification methods to be inherited by objects dynamically during run-time. This latebound event mechanism and dynamic inheritance may be provided within the context of an object model, such as the component object model, that supports only design-time interface inheritance. As applied in a virtual world environment, for example, latebound event mechanism and dynamic inheritance can provide users with increased levels of interaction or control.
In applying the latebound event mechanism of this invention to a virtual world environment, for example, the objects may correspond to the entities that would arise within the virtual world environment. The objects have associational relationships primarily representing the physical or corporeal distinctions between entities. One implementation utilizes the associations Self, Contents, and Peer. Each typical being or article entity is its own Self relative to and separate from other entities. The space or room of the virtual world environment has those entities as its contents and hence has a Contents association. Typical being or article entities are Peers of each other within a space or room. Another aspect of this particular implementation is that entities are capable of containing one or more other article entities. While such a Container entity would also be a Peer of the other entities, it is assigned to an associational class Container to reflect its functionality.
Event notification methods are promulgated among the objects corresponding to the entities in a sequence based upon the associational relationships between the entities. For an event fired or triggered with regard to one of the entities within the virtual world environment, an event notification method is passed to any objects within any Container entity before event notification methods are promulgated to objects of other entities. An event notification method is then passed to objects within the object corresponding to the Content entity. Event notification methods are then passed successively to the objects corresponding to the Self and any Peer entities.
The event notification methods relating to the Container, Contents, Self, and Peer entities may be designated OnContainerFoo, OnContentsFoo, OnFoo, and OnPeerFoo, respectively, where "Foo" is the name of the event. Each event notification method can have particular functionality according to the particular event and the entity receiving the notification.
This sequence of event notification methods provides propagation of events in a manner that reflects common causal sequences to improve the appearance of reality provided by the virtual world environment. Passing the first event notification method to the object corresponding to any Container entity has the effect of allowing the method to be applied to any container entity that has a controlling effect on another entity (e.g., any "contained" entity). For a similar reason the event notification method is passed next to the Content entity. Subsequently passing event notification methods to the Self entity and the Peer entities provides an event sequence that represents the propagation of causal effects from an event and thereby provides an improved representation of a virtual world environment. This event notification may be utilized with or without dynamic inheritance.
The updating of local object databases at client computers, dynamic inheritance, and event notification methods of this invention cooperate to provide a persistent object oriented multi-user domain capable of supporting multimedia presentation features for large numbers of users over conventional networks like the Internet. This includes distributing the objects of such a domain between a server and multiple clients and providing the objects with multimedia presentation features. Such a domain includes the persistence of conventional text-based MUDs and MOOs while also giving users the ability to vary or control a wide range of object attributes and properties. As a result, multimedia (e.g., graphical) presentation capabilities are combined with persistence and variability features of text-based MUDs and MOOs to provide a rich, dynamic, multimedia virtual world environment suitable for standard networks.
Additional objects and advantages of the present invention will be apparent from the detailed description of the preferred embodiment thereof, which proceeds with reference to the accompanying drawings.